/*
 * @Author: 鱿鱼溪学院
 * @Date: 2025-11-08 21:00:00
 * @LastEditTime: 2025-11-08 21:00:00
 * @LastEditors: 鱿鱼溪学院
 * @Description: 管理员服务，处理管理员模型相关的业务逻辑
 * @FilePath: \jmd-ser-ts\app\service\AdminService.ts
 * Copyright 鱿鱼溪学院 by edu v1.0
 * 天道酬勤
 */

import { Admin } from '../model/Admin';
import { FindOptions, WhereOptions } from 'sequelize';
import { ServiceException, NotFoundException } from '../exception';

/**
 * 管理员服务类
 * 处理管理员相关的业务逻辑
 */
export class AdminService {
  /**
   * 创建管理员
   * @param adminData 管理员数据
   * @returns 创建的管理员实例
   */
  public static async createAdmin(adminData: Partial<Admin>): Promise<Admin> {
    try {
      // 检查用户名是否已存在
      if (adminData.username) {
        const existingAdmin = await this.getAdminByUsername(adminData.username);
        if (existingAdmin) {
          throw new ServiceException('用户名已存在', 40002);
        }
      } else {
        throw new ServiceException('用户名不能为空', 40003);
      }
      
      const admin = await Admin.create(adminData);
      return admin;
    } catch (error) {
      console.error('创建管理员失败:', error);
      if (error instanceof ServiceException) {
        throw error; // 直接抛出已定义的ServiceException
      }
      throw new ServiceException(`创建管理员失败: ${(error as Error).message}`, 40001);
    }
  }

  /**
   * 根据ID获取管理员
   * @param id 管理员ID
   * @returns 管理员实例或null
   */
  public static async getAdminById(id: number): Promise<Admin | null> {
    try {
      const admin = await Admin.findByPk(id);
      return admin;
    } catch (error) {
      console.error(`获取管理员ID=${id}失败:`, error);
      throw new ServiceException(`获取管理员失败: ${(error as Error).message}`);
    }
  }

  /**
   * 根据用户名获取管理员
   * @param username 用户名
   * @returns 管理员实例或null
   */
  public static async getAdminByUsername(username: string): Promise<Admin | null> {
    try {
      const admin = await Admin.findOne({
        where: { username }
      });
      return admin;
    } catch (error) {
      console.error(`获取管理员用户名=${username}失败:`, error);
      throw new ServiceException(`获取管理员失败: ${(error as Error).message}`);
    }
  }

  /**
   * 获取管理员列表
   * @param options 查询选项
   * @returns 管理员列表
   */
  public static async getAdminList(options?: {
    page?: number;
    pageSize?: number;
    where?: WhereOptions<Admin>;
  }): Promise<{ list: Admin[]; total: number }> {
    try {
      const page = options?.page || 1;
      const pageSize = options?.pageSize || 10;
      const offset = (page - 1) * pageSize;

      const queryOptions: FindOptions<Admin> = {
        where: options?.where || {},
        offset,
        limit: pageSize,
        order: [['created_at', 'DESC']]
      };

      const { rows, count } = await Admin.findAndCountAll(queryOptions);

      return {
        list: rows,
        total: count
      };
    } catch (error) {
      console.error('获取管理员列表失败:', error);
      throw new ServiceException(`获取管理员列表失败: ${(error as Error).message}`);
    }
  }

  /**
   * 更新管理员信息
   * @param id 管理员ID
   * @param updateData 更新数据
   * @returns 更新后的管理员实例
   */
  public static async updateAdmin(id: number, updateData: Partial<Admin>): Promise<Admin> {
    try {
      const admin = await this.getAdminById(id);
      if (!admin) {
        throw new NotFoundException('管理员不存在', 40401, { adminId: id });
      }

      await admin.update(updateData);
      return admin;
    } catch (error) {
      console.error(`更新管理员ID=${id}失败:`, error);
      throw error;
    }
  }

  /**
   * 删除管理员
   * @param id 管理员ID
   * @returns 是否删除成功
   */
  public static async deleteAdmin(id: number): Promise<boolean> {
    try {
      const admin = await this.getAdminById(id);
      if (!admin) {
        throw new NotFoundException('管理员不存在', 40401, { adminId: id });
      }

      await admin.destroy();
      return true;
    } catch (error) {
      console.error(`删除管理员ID=${id}失败:`, error);
      throw error;
    }
  }

  /**
   * 验证管理员登录
   * @param username 用户名
   * @param password 密码
   * @returns 验证结果和管理员信息
   */
  public static async verifyLogin(username: string, password: string): Promise<{ success: boolean; admin?: Admin; message?: string }> {
    try {
      const admin = await this.getAdminByUsername(username);
      
      if (!admin) {
        return {
          success: false,
          message: '用户名或密码错误'
        };
      }

      // 注意：这里只是示例，实际应用中应该使用加密算法验证密码
      // 例如使用 bcrypt 或其他加密方式
      if (admin.password !== password) {
        return {
          success: false,
          message: '用户名或密码错误'
        };
      }

      // 更新最后登录时间和IP（这里需要从请求中获取IP，暂时留空）
      await admin.update({
        last_login_time: new Date()
        // last_login_ip: ip  // 从请求中获取IP
      });

      return {
        success: true,
        admin
      };
    } catch (error) {
      console.error('管理员登录验证失败:', error);
      return {
        success: false,
        message: '登录验证失败: ' + (error as Error).message
      };
    }
  }
}